home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 December / december_2000.iso / Intercd / root / Multimedia / audio / ^NoiseTracker / NtkSourceCode / alphasynth.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-09  |  22.8 KB  |  1,187 lines
  1. /*
  2. CMachineParameter const paraSM = 
  3. { 
  4.     pt_byte,                                        // type
  5.     "SyntheSys",
  6.     "SyntheSys",                                    // description
  7.     0,                                                // MinValue    
  8.     4,                                                // MaxValue
  9.     255,                                            // NoValue
  10.     MPF_STATE,                                        // Flags
  11.     0
  12. };
  13.  
  14.  
  15. CMachineParameter const paraOSC1 = 
  16. { 
  17.     pt_byte,                                        // type
  18.     "OSC1 Waveform",
  19.     "OSC1 Waveform",                                // description
  20.     0,                                                // MinValue    
  21.     8,                                                // MaxValue
  22.     255,                                            // NoValue
  23.     MPF_STATE,                                        // Flags
  24.     1
  25. };
  26.  
  27. CMachineParameter const paraPW1 = 
  28. { 
  29.     pt_word,                                        // type
  30.     "PW1",
  31.     "PW1",                                        // description
  32.     0,                                                // MinValue    
  33.     512,                                            // MaxValue
  34.     65535,                                            // NoValue
  35.     MPF_STATE,                                        // Flags
  36.     256
  37. };
  38.  
  39. CMachineParameter const paraOSC2 = 
  40. { 
  41.     pt_byte,                                        // type
  42.     "OSC2 Waveform",
  43.     "OSC2 Waveform",                                // description
  44.     0,                                                // MinValue    
  45.     8,                                                // MaxValue
  46.     255,                                            // NoValue
  47.     MPF_STATE,                                        // Flags
  48.     1
  49. };
  50.  
  51.  
  52. CMachineParameter const paraPW2 = 
  53. { 
  54.     pt_word,                                        // type
  55.     "PW2",
  56.     "PW2",                                        // description
  57.     0,                                                // MinValue    
  58.     512,                                            // MaxValue
  59.     65535,                                            // NoValue
  60.     MPF_STATE,                                        // Flags
  61.     256
  62. };
  63.  
  64. CMachineParameter const paraNoise = 
  65. { 
  66.     pt_byte,                                        // type
  67.     "Noise",
  68.     "Noise",                                // description
  69.     0,                                                // MinValue    
  70.     128,                                                // MaxValue
  71.     255,                                            // NoValue
  72.     MPF_STATE,                                        // Flags
  73.     0
  74. };
  75.  
  76. CMachineParameter const paraFine = 
  77. { 
  78.     pt_byte,                                        // type
  79.     "OSC2 Fine",
  80.     "OSC2 Fine",                                    // description
  81.     0,                                                // MinValue    
  82.     128,                                            // MaxValue
  83.     255,                                            // NoValue
  84.     MPF_STATE,                                        // Flags
  85.     64
  86. };
  87.  
  88. CMachineParameter const paraDetune = 
  89. { 
  90.     pt_byte,                                        // type
  91.     "OSC2 Detune",
  92.     "OSC2 Detune",                                    // description
  93.     0,                                                // MinValue    
  94.     128,                                            // MaxValue
  95.     255,                                            // NoValue
  96.     MPF_STATE,                                        // Flags
  97.     64
  98. };
  99.  
  100.  
  101. CMachineParameter const paraENV1_A = 
  102. { 
  103.     pt_word,                                        // type
  104.     "ENV1 Attack",
  105.     "ENV1 Attack",                                    // description
  106.     1,                                                // MinValue    
  107.     2048,                                            // MaxValue
  108.     0,                                            // NoValue
  109.     MPF_STATE,                                        // Flags
  110.     32
  111. };
  112.  
  113.  
  114. CMachineParameter const paraENV1_D = 
  115. { 
  116.     pt_word,                                        // type
  117.     "ENV1 Decay",
  118.     "ENV1 Decay",                                    // description
  119.     1,                                                // MinValue    
  120.     2048,                                            // MaxValue
  121.     0,                                            // NoValue
  122.     MPF_STATE,                                        // Flags
  123.     148
  124. };
  125.  
  126. CMachineParameter const paraENV1_S = 
  127. { 
  128.     pt_byte,                                        // type
  129.     "ENV1 Sustain",
  130.     "ENV1 Sustain",                                    // description
  131.     0,                                                // MinValue    
  132.     128,                                            // MaxValue
  133.     255,                                            // NoValue
  134.     MPF_STATE,                                        // Flags
  135.     32
  136. };
  137.  
  138. CMachineParameter const paraENV1_R = 
  139. { 
  140.     pt_word,                                        // type
  141.     "ENV1 Release",
  142.     "ENV1 Release",                                    // description
  143.     1,                                            // MinValue    
  144.     2048,                                            // MaxValue
  145.     0,                                            // NoValue
  146.     MPF_STATE,                                        // Flags
  147.     148
  148. };
  149.  
  150. CMachineParameter const paraLfo = 
  151. { 
  152.     pt_word,                                        // type
  153.     "LFO1 Period",
  154.     "LFO1 Period",                // description
  155.     0,                                                // MinValue    
  156.     2048,                                            // MaxValue
  157.     65535,                                            // NoValue
  158.     MPF_STATE,                                        // Flags
  159.     16
  160. };
  161.  
  162. CMachineParameter const paraLfo2 = 
  163. { 
  164.     pt_word,                                        // type
  165.     "LFO2 Period",
  166.     "LFO2 Period",                // description
  167.     0,                                                // MinValue    
  168.     2048,                                            // MaxValue
  169.     65535,                                            // NoValue
  170.     MPF_STATE,                                        // Flags
  171.     16
  172. };
  173.  
  174. CMachineParameter const paraVCF_Cutoff = 
  175. { 
  176.     pt_byte,                                        // type
  177.     "VCF Cutoff",
  178.     "VCF Cutoff",                                    // description
  179.     0,                                            // MinValue    
  180.     128,                                            // MaxValue
  181.     255,                                            // NoValue
  182.     MPF_STATE,                                        // Flags
  183.     128
  184. };
  185.  
  186.  
  187. CMachineParameter const paraVCF_Resonance = 
  188. { 
  189.     pt_byte,                                        // type
  190.     "VCF Q",
  191.     "VCF Q",                                    // description
  192.     0,                                            // MinValue    
  193.     128,                                            // MaxValue
  194.     255,                                            // NoValue
  195.     MPF_STATE,                                        // Flags
  196.     0
  197. };
  198.  
  199.  
  200. CMachineParameter const paraVCF_HPF = 
  201. { 
  202.     pt_byte,                                        // type
  203.     "VCF Type",
  204.     "VCF Type",                                    // description
  205.     0,                                            // MinValue    
  206.     5,                                            // MaxValue
  207.     255,                                            // NoValue
  208.     MPF_STATE,                                        // Flags
  209.     0
  210. };
  211.  
  212. CMachineParameter const paraENV1TOVCF = 
  213. { 
  214.     pt_byte,                                        // type
  215.     "VCF>ENV1",
  216.     "VCF>ENV1",                                    // description
  217.     0,                                            // MinValue    
  218.     128,                                            // MaxValue
  219.     255,                                            // NoValue
  220.     MPF_STATE,                                        // Flags
  221.     64
  222. };
  223.  
  224. CMachineParameter const paraLFOTOVCF = 
  225. { 
  226.     pt_byte,                                        // type
  227.     "VCF>LFO1",
  228.     "VCF>LFO1",                                    // description
  229.     0,                                            // MinValue    
  230.     128,                                            // MaxValue
  231.     255,                                            // NoValue
  232.     MPF_STATE,                                        // Flags
  233.     64
  234. };
  235.  
  236. CMachineParameter const paraLFOTOVCF2 = 
  237. { 
  238.     pt_byte,                                        // type
  239.     "VCF>LFO2",
  240.     "VCF>LFO2",                                    // description
  241.     0,                                            // MinValue    
  242.     128,                                            // MaxValue
  243.     255,                                            // NoValue
  244.     MPF_STATE,                                        // Flags
  245.     64
  246. };
  247.  
  248. CMachineParameter const paraLFO1TOPW1 = 
  249. { 
  250.     pt_byte,                                        // type
  251.     "PW1>LFO1",
  252.     "PW1>LFO1",                                    // description
  253.     0,                                            // MinValue    
  254.     128,                                            // MaxValue
  255.     255,                                            // NoValue
  256.     MPF_STATE,                                        // Flags
  257.     64
  258. };
  259.  
  260. CMachineParameter const paraLFO2TOPW1 = 
  261. { 
  262.     pt_byte,                                        // type
  263.     "PW1>LFO2",
  264.     "PW1>LFO2",                                    // description
  265.     0,                                            // MinValue    
  266.     128,                                            // MaxValue
  267.     255,                                            // NoValue
  268.     MPF_STATE,                                        // Flags
  269.     64
  270. };
  271.  
  272. CMachineParameter const paraLFO1TOPW2 = 
  273. { 
  274.     pt_byte,                                        // type
  275.     "PW2>LFO1",
  276.     "PW2>LFO1",                                    // description
  277.     0,                                            // MinValue    
  278.     128,                                            // MaxValue
  279.     255,                                            // NoValue
  280.     MPF_STATE,                                        // Flags
  281.     64
  282. };
  283.  
  284. CMachineParameter const paraLFO2TOPW2 = 
  285. { 
  286.     pt_byte,                                        // type
  287.     "PW2>LFO2",
  288.     "PW2>LFO2",                                    // description
  289.     0,                                            // MinValue    
  290.     128,                                            // MaxValue
  291.     255,                                            // NoValue
  292.     MPF_STATE,                                        // Flags
  293.     64
  294. };
  295.  
  296. CMachineParameter const paraGlide = 
  297. { 
  298.     pt_byte,                                        // type
  299.     "Glide",
  300.     "Glide Amount",                                    // description
  301.     0,                                                // MinValue    
  302.     128,                                            // MaxValue
  303.     255,                                            // NoValue
  304.     MPF_STATE,                                        // Flags
  305.     0
  306. };
  307.  
  308. CMachineParameter const paraNote = 
  309. { 
  310.     pt_note,                                        // type
  311.     "Note",
  312.     "Note",                                            // description
  313.     NOTE_MIN,                                             // MinValue    
  314.     NOTE_MAX,                                                  // MaxValue
  315.     NOTE_NO,                                        // NoValue
  316.     0,                                                // Flags
  317.     0
  318. };
  319.  
  320. CMachineParameter const paraVolume = 
  321. { 
  322.     pt_byte,                                        // type
  323.     "Volume",
  324.     "Volume [sustain level] (0=0%, 80=100%, FE=~200%)",    // description
  325.     0,                                                // MinValue    
  326.     0xfe,                                              // MaxValue
  327.     0xff,                                            // NoValue
  328.     0,                                        // Flags
  329.     0x80
  330. };
  331.  
  332. CMachineParameter const *pParameters[] = { 
  333.     // global
  334.     ¶SM,
  335.     ¶OSC1,
  336.     ¶PW1,
  337.     ¶OSC2,
  338.     ¶PW2,
  339.     ¶Noise,
  340.     ¶Fine,
  341.     ¶Detune,
  342.     ¶ENV1_A,
  343.     ¶ENV1_D,
  344.     ¶ENV1_S,
  345.     ¶ENV1_R,
  346.     ¶Lfo,
  347.     ¶Lfo2,
  348.     ¶VCF_Cutoff,
  349.     ¶VCF_Resonance,
  350.     ¶VCF_HPF,
  351.     ¶ENV1TOVCF,
  352.     ¶LFOTOVCF,
  353.     ¶LFOTOVCF2,
  354.     ¶LFO1TOPW1,
  355.     ¶LFO2TOPW1,
  356.     ¶LFO1TOPW2,
  357.     ¶LFO2TOPW2,
  358.     ¶Glide,
  359.     
  360.     // track
  361.     ¶Note,
  362.     ¶Volume
  363. };
  364.  
  365. #pragma pack(1)
  366.  
  367. class gvals
  368. {
  369. public:
  370. byte sm;
  371. byte osc1;
  372. word pw1;
  373. byte osc2;
  374. word pw2;
  375. byte noise;
  376. byte fine;
  377. byte detune;
  378. word env1_a;
  379. word env1_d;
  380. byte env1_s;
  381. word env1_r;
  382. word lfo;
  383. word lfo2;
  384. byte vcf_cutoff;
  385. byte vcf_resonance;
  386. byte vcf_hpf;
  387. byte env1tovcf;
  388. byte lfotovcf;
  389. byte lfotovcf2;
  390. byte lfo1topw1;
  391. byte lfo2topw1;
  392. byte lfo1topw2;
  393. byte lfo2topw2;
  394. byte glide;
  395. };
  396.  
  397. class tvals
  398. {
  399. public:
  400.     byte note;
  401.     byte volume;
  402. };
  403.  
  404. #pragma pack()
  405.  
  406. CMachineInfo const MacInfo = 
  407. {
  408.     MT_GENERATOR,                            // type
  409.     MI_VERSION,
  410.     0,                                        // flags
  411.     1,                                        // min tracks
  412.     MAX_TRACKS,                                // max tracks
  413.     25,                                        // numGlobalParameters
  414.     2,                                        // numTrackParameters
  415.     pParameters,
  416.     0, 
  417.     NULL,
  418. #ifdef _DEBUG
  419.     "Arguelles Alpha (Debug build)",            // name
  420. #else
  421.     "Arguelles Alpha",
  422. #endif
  423.     "Alpha",                                    // short name
  424.     "Juan Antonio Arguelles Rius",             // author
  425.     NULL
  426. };
  427.  
  428. class Alphatrack
  429. {
  430. public:
  431.     mi();
  432.     virtual ~mi();
  433.     
  434.     virtual float Filter(char c,float input,float f,float q);
  435.     virtual float Filter2( float x, char i);
  436.     virtual void MakeBW(void);
  437.     float Kutoff( int v);
  438.     float Reonance( float v);
  439.     float Bandwidth( int v);
  440.     void ComputeCoefs(int freq, int r, int t);
  441.  
  442.     virtual void Init(CMachineDataInput * const pi);
  443.     virtual void Tick();
  444.     virtual bool Work(float *psamples, int numsamples, int const mode);
  445.     virtual void SetNumTracks(int const n) { numTracks = n; }
  446.     virtual void Stop();
  447.     virtual void InitWavetable();
  448.     virtual void SynthNote(char channel,float note);
  449.     virtual float SynthWork(char channel);
  450.     virtual float ADSR_Coef(float sustain,int stage);
  451.     virtual void LfoAdvance(void);
  452.     virtual int f2i(double d);
  453.     virtual char const *DescribeValue(int const param, int const value);
  454.     virtual float GetS(int type,float offset, float pwi);
  455.  
  456. public:
  457.     int numTracks;
  458.     gvals gval;
  459.     tvals tval;
  460.     float SineTable[600];
  461.     float coef[5];
  462.     float coeftab[5][128][128][5];
  463.     float OSC1_Step;
  464.     float OSC2_Step;
  465.     int ENV1_A;
  466.     int ENV1_D;
  467.     float ENV1_S;
  468.     int ENV1_R;
  469.     float buf0;
  470.     float buf1;
  471.     float fy2;
  472.     float fy1;
  473.     float fx2;
  474.     float fx1;
  475.     float Pw1;
  476.     float Pw2;
  477.     float ENV1TOVCF;
  478.     float LFOTOVCF;
  479.     float LFOTOVCF2;
  480.     float LFO1TOPW1;
  481.     float LFO2TOPW1;
  482.     float LFO1TOPW2;
  483.     float LFO2TOPW2;
  484.  
  485.     int VReso;    
  486.     float Vcf_Cutoff;
  487.     float Vcf_Resonance;
  488.     char Vcf_Hpf;
  489.     char sm;
  490.     float Fine,Detune;
  491.     union res_acc
  492.     {
  493.     unsigned __int16 short_acc[2];
  494.     unsigned __int32 long_acc;
  495.     };
  496.     float OSC1_Position;
  497.     float OSC2_Position;
  498.  
  499.     char OSC1,OSC2;
  500.     float Noise;
  501.     float OSC1_Volume;
  502.     char  ENV1_Stage;
  503.     int ENV1_Counter;
  504.     float CVol;
  505.     float TVol;
  506.     float ENV1_Val;
  507.     int Period;    
  508.     int Period2;    
  509.     int Gr,Gr2;
  510.     int SubGrCounter,SubGrCounter2;
  511.     int SubGrMax,SubGrMax2;
  512.     float final;
  513.     int VCutoff;
  514. };
  515.  
  516. DLL_EXPORTS
  517.  
  518. mi::mi()
  519. {
  520.     GlobalVals = &gval;
  521.     TrackVals = tval;
  522.     AttrVals = NULL;
  523. }
  524.  
  525. mi::~mi()
  526. {
  527.  
  528. }
  529.  
  530. void mi::Init(CMachineDataInput * const pi)
  531. {
  532.     Vcf_Cutoff=1.0f;
  533.     Vcf_Resonance=0.0f;
  534.     Vcf_Hpf=0;
  535.     sm=0;
  536.     Fine=0.5;
  537.     VCutoff=0;
  538.     Detune=0.0f;
  539.     final=0;
  540.     OSC1=1;
  541.     OSC2=1;
  542.     Pw1=256;
  543.     Pw2=256;
  544.     ENV1_A=1024;
  545.     ENV1_D=22100;
  546.     ENV1_S=0.3f;
  547.     ENV1_R=22100;
  548.     ENV1TOVCF=0.0f;
  549.     LFOTOVCF=0.0f;
  550.     LFOTOVCF2=0.0f;
  551.     LFO1TOPW1=0.0f;
  552.     LFO2TOPW1=0.0f;
  553.     LFO1TOPW2=0.0f;
  554.     LFO2TOPW2=0.0f;
  555.     
  556.     VReso=0;
  557.     Noise=0;
  558.     Period=16;
  559.     Period2=16;
  560.     Gr=0;
  561.     Gr2=0;
  562.  
  563.     SubGrCounter=0;
  564.     SubGrCounter2=0;
  565.  
  566.     SubGrMax=200;
  567.     SubGrMax2=200;
  568.     
  569.     OSC1_Step=0;
  570.     OSC1_Position=0;
  571.     OSC2_Step=0;
  572.     OSC2_Position=0;
  573.     OSC1_Volume=1.0f;
  574.     ENV1_Stage=0;
  575.     ENV1_Counter=0;
  576.     CVol=0.0f;
  577.     TVol=0.0f;
  578.     ENV1_Val=0.0f;
  579.     buf0=0.0f;
  580.     buf1=0.0f;
  581.     fy2=0.0f;
  582.     fy1=0.0f;
  583.     fx2=0.0f;
  584.     fx1=0.0f;
  585.     }
  586.     MakeBW();
  587.     InitWavetable();
  588. }
  589.  
  590. void mi::Tick()
  591. {
  592.     sm=gval.sm;
  593.  
  594.     OSC1=gval.osc1;
  595.  
  596.     Pw1=(float)gval.pw1;
  597.  
  598.     OSC2=gval.osc2;
  599.  
  600.     Pw2=(float)gval.pw2;
  601.  
  602.     Noise=(float)gval.noise/128.0f;
  603.  
  604.     Fine=(float)gval.fine/128.0f;
  605.  
  606.     Detune=(float)gval.detune-64.0f;
  607.  
  608.     ENV1_A=(int)gval.env1_a*(int)gval.env1_a;
  609.         
  610.     ENV1_D=gval.env1_d*(int)gval.env1_d;
  611.  
  612.     ENV1_S=(float)gval.env1_s/128.0f;
  613.     
  614.     ENV1_R=gval.env1_r*(int)gval.env1_r;
  615.  
  616.     Vcf_Cutoff=(float)gval.vcf_cutoff/128.0f;
  617.  
  618.     Vcf_Resonance=(float)gval.vcf_resonance/128.0f;
  619.     VReso=f2i(Vcf_Resonance*127.0f);
  620.  
  621.     Vcf_Hpf=gval.vcf_hpf;
  622.  
  623.     ENV1TOVCF=((float)gval.env1tovcf-64.0f)/64.0f;
  624.  
  625.     Period = gval.lfo;
  626.     SubGrMax=(SamplesPerTick/3600)*Period;
  627.  
  628.     Period2 = gval.lfo2;
  629.     SubGrMax2=(SamplesPerTick/3600)*Period2;
  630.  
  631.     LFOTOVCF=((float)gval.lfotovcf-64.0f)/64.0f;
  632.     LFOTOVCF2=((float)gval.lfotovcf2-64.0f)/64.0f;
  633.     LFO1TOPW1=((float)gval.lfo1topw1-64.0f)*4;
  634.     LFO2TOPW1=((float)gval.lfo2topw1-64.0f)*4;
  635.     LFO1TOPW2=((float)gval.lfo1topw2-64.0f)*4;
  636.     LFO2TOPW2=((float)gval.lfo2topw2-64.0f)*4;
  637.  
  638.     if(tval[c].note!=NOTE_NO)
  639.         {
  640.             if(tval[c].note==NOTE_OFF)
  641.             {
  642.                 // Note off on track c
  643.                 ENV1_Stage[c]=4;
  644.                 TVol[c]=ENV1_S;
  645.                 ENV1_Counter[c]=1;
  646.             }
  647.             else
  648.             {
  649.                 // Note on on track c
  650.  
  651.             float tNote =(float) ((tval[c].note>>4)*12+(tval[c].note&0x0f)-1)-41;
  652.             SynthNote(c,tNote);
  653.             }
  654.         }
  655.         
  656.         if(tval[c].volume!=paraVolume.NoValue)
  657.             OSC1_Volume[c]=(float)tval[c].volume/128.0f;
  658.         
  659.     }
  660. }
  661.  
  662. bool mi::Work(float *psamples, int numsamples, int const)
  663. {
  664.     bool gotsomething = false;
  665. do{
  666.     final=0;
  667.     LfoAdvance();
  668.     for (int c = 0; c < numTracks; c++)
  669.     {
  670.         float freak=0;
  671.         if (ENV1_Stage[c]>0)
  672.         {
  673.             freak=SynthWork(c);
  674.             gotsomething=true;    
  675.         }
  676.         float FinalC=Vcf_Cutoff+SineTable[Gr]*LFOTOVCF+SineTable[Gr2]*LFOTOVCF2+ENV1_Val[c]*ENV1TOVCF;
  677.         
  678.         switch(Vcf_Hpf)
  679.         {
  680.         case 0:
  681.         VCutoff=f2i(FinalC*128.0f);
  682.         if (VCutoff>127)VCutoff=127;
  683.         if (VCutoff<0)VCutoff=0;
  684.  
  685.         coef[0]=coeftab[0][VCutoff][VReso][0];
  686.         coef[1]=coeftab[1][VCutoff][VReso][0];
  687.         coef[2]=coeftab[2][VCutoff][VReso][0];
  688.         coef[3]=coeftab[3][VCutoff][VReso][0];
  689.         coef[4]=coeftab[4][VCutoff][VReso][0];
  690.         freak=Filter2(freak++,c);
  691.         break;
  692.  
  693.         case 1:
  694.         VCutoff=f2i(FinalC*128.0f);
  695.         if (VCutoff>127)VCutoff=127;
  696.         if (VCutoff<0)VCutoff=0;
  697.  
  698.         coef[0]=coeftab[0][VCutoff][VReso][1];
  699.         coef[1]=coeftab[1][VCutoff][VReso][1];
  700.         coef[2]=coeftab[2][VCutoff][VReso][1];
  701.         coef[3]=coeftab[3][VCutoff][VReso][1];
  702.         coef[4]=coeftab[4][VCutoff][VReso][1];
  703.         freak=Filter2(freak++,c);
  704.         break;
  705.  
  706.         case 2:
  707.  
  708.         VCutoff=f2i(FinalC*128.0f);
  709.         if (VCutoff>127)VCutoff=127;
  710.         if (VCutoff<0)VCutoff=0;
  711.  
  712.         coef[0]=coeftab[0][VCutoff][VReso][2];
  713.         coef[1]=coeftab[1][VCutoff][VReso][2];
  714.         coef[2]=coeftab[2][VCutoff][VReso][2];
  715.         coef[3]=coeftab[3][VCutoff][VReso][2];
  716.         coef[4]=coeftab[4][VCutoff][VReso][2];
  717.         freak=Filter2(freak++,c);
  718.         break;
  719.  
  720.         case 3:
  721.  
  722.         VCutoff=f2i(FinalC*128.0f);
  723.         if (VCutoff>127)VCutoff=127;
  724.         if (VCutoff<0)VCutoff=0;
  725.  
  726.         coef[0]=coeftab[0][VCutoff][VReso][3];
  727.         coef[1]=coeftab[1][VCutoff][VReso][3];
  728.         coef[2]=coeftab[2][VCutoff][VReso][3];
  729.         coef[3]=coeftab[3][VCutoff][VReso][3];
  730.         coef[4]=coeftab[4][VCutoff][VReso][3];
  731.         freak=Filter2(freak++,c);
  732.         break;
  733.  
  734.         case 4:freak=Filter(c,freak,FinalC,Vcf_Resonance);break;
  735.  
  736.         }
  737.  
  738.  
  739.         final+=freak;
  740.     }
  741.     *psamples++=final;
  742. }while(--numsamples);
  743.  
  744.     return gotsomething;
  745. }
  746.  
  747. void mi::Stop()
  748. {
  749.     for (int c = 0; c < numTracks; c++)
  750.         ENV1_Stage[c]=0;
  751. }
  752.  
  753. void mi::InitWavetable()
  754. {
  755.     SineTable[c]=(float)sin((float)c*0.0174532f);
  756. }
  757.  
  758. }
  759.  
  760. void mi::SynthNote(char channel,float note)
  761. {
  762.     ENV1_Stage[channel]=1;
  763.     ENV1_Counter[channel]=0;
  764.     ENV1_Val[channel]=0.0f;
  765.     OSC1_Step[channel]=(float)pow(2.0,note/12.0f);
  766.     OSC2_Step[channel]=(float)pow(2.0,(note+Fine+Detune)/12.0f);
  767. }
  768.  
  769. float mi::SynthWork(char channel)
  770. {
  771.     
  772.     float OSC1Result=GetS(OSC1,OSC1_Position[channel],Pw1+SineTable[Gr]*LFO1TOPW1+SineTable[Gr2]*LFO2TOPW1);
  773.     OSC1_Position[channel]+=OSC1_Step[channel];
  774.     if(OSC1_Position[channel]>=512)OSC1_Position[channel]-=512;
  775.     
  776.     float OSC2Result=GetS(OSC2,OSC2_Position[channel],Pw2+SineTable[Gr]*LFO1TOPW2+SineTable[Gr2]*LFO2TOPW2);
  777.     OSC2_Position[channel]+=OSC2_Step[channel];
  778.     if(OSC2_Position[channel]>=512)OSC2_Position[channel]-=512;
  779.  
  780.     switch(ENV1_Stage[channel])
  781.     {
  782.     case 1:
  783.         ENV1_Counter[channel]++;
  784.         ENV1_Val[channel]+=ADSR_Coef(ENV1_S,1);
  785.         if (ENV1_Counter[channel]>=ENV1_A)
  786.         {
  787.             ENV1_Counter[channel]=1;
  788.             ENV1_Stage[channel]=2;
  789.         }
  790.     break;
  791.  
  792.     case 2:
  793.         ENV1_Counter[channel]++;
  794.         ENV1_Val[channel]-=ADSR_Coef(ENV1_S,2);
  795.         
  796.         if (ENV1_Counter[channel]>=ENV1_D)
  797.         {
  798.             ENV1_Counter[channel]=1;
  799.             if (ENV1_S<0.01f)
  800.             ENV1_Stage[channel]=5;
  801.             else
  802.             ENV1_Stage[channel]=3;
  803.         }
  804.     break;
  805.     
  806.     case 3:
  807.     ENV1_Val[channel]=ENV1_S;
  808.     break;
  809.  
  810.     case 4:
  811.         ENV1_Counter[channel]++;
  812.         ENV1_Val[channel]-=ADSR_Coef(ENV1_S,4);
  813.         
  814.         if (ENV1_Counter[channel]>=ENV1_R)
  815.         {
  816.             ENV1_Counter[channel]=0;
  817.             ENV1_Stage[channel]=5;
  818.         }
  819.     break;
  820.     }
  821.  
  822.     if (ENV1_Stage[channel]<5)
  823.     {
  824.     TVol[channel]=OSC1_Volume[channel]*ENV1_Val[channel];
  825.     }
  826.     else
  827.     {
  828.     TVol[channel]=0.0f;
  829.     if (CVol[channel]<0.0002f)ENV1_Stage[channel]=0;
  830.     }
  831.  
  832.     float ad=TVol[channel]-CVol[channel];
  833.  
  834.     if (ad>0.00001f || ad<-0.00001f)
  835.         CVol[channel]+=ad/256.0f;
  836.     float Noiser=Noise*(rand()-16384.0f);
  837.     
  838.     float OSCSResults;
  839.     switch (sm){
  840.     case 0:
  841.     OSCSResults=OSC1Result+OSC2Result;
  842.     break;
  843.     case 1:
  844.     OSCSResults=OSC1Result-OSC2Result;
  845.     break;
  846.     case 2:
  847.     OSCSResults=OSC1Result*(OSC2Result/32768.0f);
  848.     break;
  849.     case 3:
  850.     OSCSResults=float(f2i(OSC1Result) & f2i(OSC2Result));
  851.     break;
  852.     case 4:
  853.     OSCSResults=float(f2i(OSC1Result) | f2i(OSC2Result));
  854.     break;
  855.     
  856.     }
  857.     return (Noiser+OSCSResults)*CVol[channel];
  858.     
  859. }
  860.  
  861. float mi::ADSR_Coef(float sustain,int stage)
  862. {
  863.     float coef=0.0f;
  864.  
  865.     switch(stage)
  866.     {
  867.     case 1:
  868.         coef=(float)1.0f/(float)ENV1_A;
  869.     break;
  870.     
  871.     case 2:
  872.         coef=(1.0f-sustain)/(float)ENV1_D;
  873.     break;
  874.     
  875.     case 3:
  876.         coef=0;
  877.     break;
  878.  
  879.     case 4:
  880.         coef=sustain/(float)ENV1_R;
  881.     break;
  882.     }
  883.     return coef;
  884. }
  885.  
  886. float mi::Filter(char c,float input,float f,float q)
  887. {
  888.   input++;
  889.   if (f>0.95f)f=0.95f;
  890.   if (f<0.05f)f=0.05f;
  891.   if (q>0.95f)q=0.95f;
  892.   if (q<0.05f)q=0.05f;
  893.   
  894.   float fa = 1.0f - f; 
  895.   float fb = q * (1.0f + 1.0f/fa);
  896.   buf0[c] = fa * buf0[c] + f * (input + fb * (buf0[c] - buf1[c])); 
  897.   buf1[c] = fa * buf1[c] + f * buf0[c];
  898.   return buf1[c];  
  899. }
  900.  
  901. void mi::LfoAdvance(void)
  902. {
  903.         SubGrCounter++;
  904.         SubGrCounter2++;
  905.         
  906.         if(SubGrCounter>SubGrMax){
  907.             SubGrCounter=0;
  908.             Gr++;
  909.             if(Gr>359)
  910.                 Gr=0;
  911.         }
  912.         
  913.         if(SubGrCounter2>SubGrMax2){
  914.             SubGrCounter2=0;
  915.             Gr2++;
  916.             if(Gr2>359)
  917.                 Gr2=0;
  918.         }
  919. }
  920.  
  921.  
  922. int mi::f2i(double d)
  923. {
  924.   const double magic = 6755399441055744.0; // 2^51 + 2^52
  925.   double tmp = (d-0.5) + magic;
  926.   return *(int*) &tmp;
  927. }
  928.  
  929. char const *mi::DescribeValue(int const param, int const value)
  930. {
  931.     static char txt[16];
  932.  
  933.     switch(param)
  934.     {
  935.     case 0:
  936.     switch(value)
  937.         {
  938.         case 0: return "Add";break;
  939.         case 1: return "Sub";break;
  940.         case 2: return "AM";break;
  941.         case 3: return "And";break;
  942.         case 4: return "Or";break;
  943.         }
  944.     break;
  945.     case 1:
  946.         switch(value)
  947.         {
  948.         case 0: return "Sine";break;
  949.         case 1: return "Sawtooth";break;
  950.         case 2: return "Pulse";break;
  951.         case 3: return "PW Value";break;
  952.         case 4: return "-Sawtooth";break;
  953.         case 5: return "RndWave";break;
  954.         case 6: return "None";break;
  955.         case 7: return "None";break;
  956.         case 8: return "Off";break;
  957.         }
  958.     break;
  959.  
  960.     case 3:
  961.         switch(value)
  962.         {
  963.         case 0: return "Sine";break;
  964.         case 1: return "Sawtooth";break;
  965.         case 2: return "Pulse";break;
  966.         case 3: return "PW Value";break;
  967.         case 4: return "-Sawtooth";break;
  968.         case 5: return "RndWave";break;
  969.         case 6: return "None";break;
  970.         case 7: return "None";break;
  971.         case 8: return "Off";break;
  972.         }
  973.     break;
  974.  
  975.     case 5:
  976.         sprintf(txt, "%2.1f%%", (float)value*0.78125f);
  977.     break;
  978.     
  979.     case 6:
  980.         sprintf(txt, "%d Units", value);
  981.     break;
  982.     
  983.     case 7:
  984.         sprintf(txt, "%d SemiTns.", (int)value-64);
  985.     break;
  986.  
  987.     case 10:
  988.         sprintf(txt, "%2.1f%%", (float)value*0.78125f);
  989.     break;
  990.  
  991.     case 12:
  992.         sprintf(txt, "%2.1f Ticks", (float)value/10.0f);
  993.     break;
  994.     
  995.     case 13:
  996.         sprintf(txt, "%2.1f Ticks", (float)value/10.0f);
  997.     break;
  998.  
  999.     case 16:
  1000.         switch(value)
  1001.         {
  1002.         case 0: return "LP12";break;
  1003.         case 1: return "HP";break;
  1004.         case 2: return "BP";break;
  1005.         case 3: return "BR";break;
  1006.         case 4: return "LP24";break;
  1007.         case 5: return "Off";break;
  1008.         }
  1009.     break;
  1010.  
  1011.     case 17:
  1012.         sprintf(txt, "%2.1f%%", ((float)value-64.0f)*1.5625f);
  1013.     break;
  1014.  
  1015.     case 18:
  1016.         sprintf(txt, "%2.1f%%", ((float)value-64.0f)*1.5625f);
  1017.     break;
  1018.  
  1019.     case 19:
  1020.         sprintf(txt, "%2.1f%%", ((float)value-64.0f)*1.5625f);
  1021.     break;
  1022.  
  1023.     case 20:
  1024.         sprintf(txt, "%2.1f%%", ((float)value-64.0f)*1.5625f);
  1025.     break;
  1026.  
  1027.     case 21:
  1028.         sprintf(txt, "%2.1f%%", ((float)value-64.0f)*1.5625f);
  1029.     break;
  1030.  
  1031.     case 22:
  1032.         sprintf(txt, "%2.1f%%", ((float)value-64.0f)*1.5625f);
  1033.     break;
  1034.  
  1035.     case 23:
  1036.         sprintf(txt, "%2.1f%%", ((float)value-64.0f)*1.5625f);
  1037.     break;
  1038.  
  1039.  
  1040.     default:
  1041.     return NULL;
  1042.     }
  1043.     return txt;
  1044. }
  1045.  
  1046. void mi::MakeBW(void)
  1047. {
  1048. for (int cutt=0;cutt<128;cutt++)
  1049. {
  1050. for (int rezz=0;rezz<128;rezz++)
  1051. {
  1052. for (int typp=0;typp<4;typp++)
  1053. {
  1054. ComputeCoefs(cutt,rezz,typp);
  1055. coeftab[0][cutt][rezz][typp]=coef[0];        
  1056. coeftab[1][cutt][rezz][typp]=coef[1];
  1057. coeftab[2][cutt][rezz][typp]=coef[2];
  1058. coeftab[3][cutt][rezz][typp]=coef[3];
  1059. coeftab[4][cutt][rezz][typp]=coef[4];
  1060. }}}
  1061.  
  1062. }
  1063.  
  1064. void mi::ComputeCoefs(int freq, int r, int t)
  1065. {
  1066.     float omega =float (2*PI*Kutoff(freq)/44100);
  1067.     float sn = (float)sin( omega);
  1068.     float cs = (float)cos( omega);
  1069.     float alpha;
  1070.         
  1071.     if( t<2)
  1072.     alpha =float(sn / Reonance( r *(freq+70)/(127.0f+70)));
  1073.     else
  1074.     alpha =float (sn * sinh( Bandwidth( r) * omega/sn));
  1075.  
  1076.         float a0, a1, a2, b0, b1, b2;
  1077.  
  1078.         switch( t)
  1079.         {
  1080.     
  1081.         case 0: // LP
  1082.                 b0 =  (1 - cs)/2;
  1083.                 b1 =   1 - cs;
  1084.                 b2 =  (1 - cs)/2;
  1085.                 a0 =   1 + alpha;
  1086.                 a1 =  -2*cs;
  1087.                 a2 =   1 - alpha;
  1088.                 break;
  1089.         case 1: // HP
  1090.                 b0 =  (1 + cs)/2;
  1091.                 b1 = -(1 + cs);
  1092.                 b2 =  (1 + cs)/2;
  1093.                 a0 =   1 + alpha;
  1094.                 a1 =  -2*cs;
  1095.                 a2 =   1 - alpha;
  1096.                 break;
  1097.         case 2: // BP
  1098.                 b0 =   alpha;
  1099.                 b1 =   0;
  1100.                 b2 =  -alpha;
  1101.                 a0 =   1 + alpha;
  1102.                 a1 =  -2*cs;
  1103.                 a2 =   1 - alpha;
  1104.                 break;
  1105.         case 3: // BR
  1106.                 b0 =   1;
  1107.                 b1 =  -2*cs;
  1108.                 b2 =   1;
  1109.                 a0 =   1 + alpha;
  1110.                 a1 =  -2*cs;
  1111.                 a2 =   1 - alpha;
  1112.                 break;
  1113.         }
  1114.  
  1115.         coef[0] = b0/a0;
  1116.         coef[1] = b1/a0;
  1117.         coef[2] = b2/a0;
  1118.         coef[3] = -a1/a0;
  1119.         coef[4] = -a2/a0;
  1120. }
  1121.     
  1122.  
  1123. float mi::Kutoff( int v)
  1124. {
  1125.         return float(pow( (v+5)/(127.0+5), 1.7)*13000+30);
  1126. }
  1127.  
  1128. float mi::Reonance( float v)
  1129. {
  1130.         return float(pow( v/127.0, 4)*150+0.1);
  1131. }
  1132.  
  1133. float mi::Bandwidth( int v)
  1134. {
  1135.         return float(pow( v/127.0, 4)*4+0.1);
  1136. }
  1137.  
  1138. float mi::Filter2(float x)
  1139. {
  1140.         float y;
  1141.         y = coef[0]*x + coef[1]*fx1 + coef[2]*fx2 + coef[3]*fy1 + coef[4]*fy2;
  1142.         fy2=fy1;
  1143.         fy1=y;
  1144.         fx2=fx1;
  1145.         fx1=x;
  1146.         return y;
  1147. }
  1148.  
  1149. float mi::GetS(int type,float offset, float pwi)
  1150. {
  1151. switch(type)
  1152.     {
  1153.         case 0: return (float)sin(offset*0.0122718f)*16384;break;
  1154.         case 1: return (offset-256)*64.0f;break;
  1155.         case 2: 
  1156.             if (pwi<2)pwi=2;
  1157.             if (pwi>510)pwi=510;
  1158.  
  1159.             if (offset<pwi)
  1160.             return 16384;
  1161.             else
  1162.             return -16384;
  1163.         break;
  1164.         
  1165.         case 3: return (pwi-256)*64;break;
  1166.         case 4: return (offset-256)*-64.0f;break;
  1167.         
  1168.         case 5:
  1169.             if (pwi<2)pwi=2;
  1170.             if (pwi>510)pwi=510;
  1171.  
  1172.             if (offset<pwi)
  1173.             return (float)rand()-8192;
  1174.             else
  1175.             return 0;
  1176.         break;
  1177.         
  1178.         case 6: return 0;break;
  1179.         case 7: return 0;break;
  1180.         case 8: return 0;break;
  1181.         default:
  1182.             return 0;
  1183.         break;
  1184.     }
  1185. }
  1186. */
  1187.